/*
	Работа с RTC
*/

#include "defines.h"

U8 monthes[] = {31,28,31,30,31,30,31,31,30,31,30,31};
/*
	Настройка RTC
*/
void rtc_init(void)
{
	DateTimeT Time;
	
	//Подаем клоки на RTC
  LPC_SC->PCONP |= (1 << 9);

  //Если RTC остановлен, то очищаем бит
  if ( LPC_RTC->RTC_AUX & (0x1<<4) )
  {
		LPC_RTC->RTC_AUX |= (0x1<<4);	
  }
  
  //Инициализируем регистры
  LPC_RTC->AMR = 0;
  LPC_RTC->CIIR = 0;
  LPC_RTC->CCR = 0;
	
	//Старт
	LPC_RTC->CCR |= CCR_CLKEN;
	
	//Считываем время и проверяем
	Time = rtc_get_time();
	
	
	
	//Время какое то кривое - надо подправить
	if (Time.Year<2013)
	{
		//Настройка времени
		Time.Sec = 00;
		Time.Min=00;
		Time.Hour=12;
		Time.Mday=25;
		Time.Mon=11;
		Time.Year=2014;
		rtc_set_time(Time);
	}
	
	//rtc_set_time_in_ticks(635098238220000000);
	
	//Отобразим текущее время
	Time = rtc_get_time();
	printf("Date and Time: %02d.%02d.%02d %02d:%02d:%02d\r\n",Time.Mday,Time.Mon,Time.Year,Time.Hour,Time.Min, Time.Sec);
}
	

/*
	Установка времени
*/
void rtc_set_time(DateTimeT dt)
{
	LPC_RTC->SEC = dt.Sec;
  LPC_RTC->MIN = dt.Min;
  LPC_RTC->HOUR = dt.Hour;
  LPC_RTC->DOM = dt.Mday;
  //LPC_RTC->DOW = ??
  LPC_RTC->DOY = get_Yday(dt);
  LPC_RTC->MONTH = dt.Mon;
  LPC_RTC->YEAR = dt.Year;    
}

/*
	Установка времени исходя из тиков
*/
U8 rtc_set_time_in_ticks(U64 ticks)
{
	//Сначала надо перевести в человеческий вид
	DateTimeT dt = ticks_to_time(ticks);
	//Надо проверить на логичность времени
	if (dt.Year<2001||dt.Year>2100)
		return 0;
	
	//А теперь задаем время
	rtc_set_time(dt);
	return 1;
}

/*
	Считываем время
*/
DateTimeT rtc_get_time( void ) 
{
  DateTimeT LocalTime;
    
  LocalTime.Sec = LPC_RTC->SEC;
  LocalTime.Min = LPC_RTC->MIN;
  LocalTime.Hour = LPC_RTC->HOUR;
  LocalTime.Mday = LPC_RTC->DOM;
  LocalTime.Mon = LPC_RTC->MONTH;
  LocalTime.Year = LPC_RTC->YEAR;

  return ( LocalTime );    
}

/*
	Считываем время в тиках
*/
U64  rtc_get_time_in_ticks(void)
{
	DateTimeT dt;
	U64 ticks;
	//Сначала считываем время
	dt = rtc_get_time();
	//..а теперь переводим в тики
	ticks = time_to_ticks(dt);
	return ticks;
}

/*
	Перевод нашего времени в тики
*/
U64 time_to_ticks(DateTimeT dt)
{
	U64 r=0;
	U16 Yday;
	
	Yday = get_Yday(dt);
	
	
	/*
	//Linux ticks - in seconds since 1970
	dt.Year=dt.Year-1900;
	r = (U64)dt.Sec+((U64)dt.Min)*60+((U64)dt.Hour)*3600+((U64)Yday-1)*86400+((U64)(dt.Year-70))*31536000
	+((U64)((dt.Year-69)/4))*86400	- (U64)(((dt.Year-1)/100))*86400+((U64)((dt.Year+299)/400))*86400;
	*/
	
	
	//Windows ticks - in 100 nanoseconds since 2001
	r = (U64)dt.Sec+((U64)dt.Min)*60+((U64)dt.Hour)*3600+((U64)Yday-1)*86400+((U64)(dt.Year-01))*31536000
	+((U64)((dt.Year-00)/4))*86400	- (U64)(((dt.Year-1)/100))*86400+((U64)((dt.Year+299)/400))*86400;
	r = r*10000000;
	
	return r;
}

/*
	Определяем номер дня года
*/
U16 get_Yday(DateTimeT dt)
{
	U16 result=0;
	U8 i;
	for (i=0;i<dt.Mon-1;i++)
		result +=monthes[i];
	result+=dt.Mday;
	
	//Если год високосный?
	if ((dt.Year%100)%4==0)
	{
		if (result>=59)
			result++;
	}
	return result;
}

/*
	Перевод тиков в нормальную дату
*/
#define uint U16

DateTimeT ticks_to_time(U64 SecondsSinceEpoch)
{
  DateTimeT dt;
	U64 sec;
  uint quadricentennials, centennials, quadrennials, annuals/*1-ennial?*/;
  uint year, leap;
  uint yday, hour, min;
  uint month, mday, wday;
  static const uint daysSinceJan1st[2][13]=
  {
    {0,31,59,90,120,151,181,212,243,273,304,334,365}, // 365 days, non-leap
    {0,31,60,91,121,152,182,213,244,274,305,335,366}  // 366 days, leap
  };

  // Re-bias from 1970 to 1601:
  // 1970 - 1601 = 369 = 3*100 + 17*4 + 1 years (incl. 89 leap days) =
  // (3*100*(365+24/100) + 17*4*(365+1/4) + 1*365)*24*3600 seconds
	
	//Тут корректировка для Win ticks
	SecondsSinceEpoch = SecondsSinceEpoch/10000000; //100-наносекунды переведем в секунды
	SecondsSinceEpoch = SecondsSinceEpoch + 978307200;//Добавим время до 1 января 2001 года
	
  sec = SecondsSinceEpoch + 11644473600;

  wday = (uint)((sec / 86400 + 1) % 7); // day of week

  // Remove multiples of 400 years (incl. 97 leap days)
  quadricentennials = (uint)(sec / 12622780800ULL); // 400*365.2425*24*3600
  sec %= 12622780800ULL;

  // Remove multiples of 100 years (incl. 24 leap days), can't be more than 3
  // (because multiples of 4*100=400 years (incl. leap days) have been removed)
  centennials = (uint)(sec / 3155673600ULL); // 100*(365+24/100)*24*3600
  if (centennials > 3)
  {
    centennials = 3;
  }
  sec -= centennials * 3155673600ULL;

  // Remove multiples of 4 years (incl. 1 leap day), can't be more than 24
  // (because multiples of 25*4=100 years (incl. leap days) have been removed)
  quadrennials = (uint)(sec / 126230400); // 4*(365+1/4)*24*3600
  if (quadrennials > 24)
  {
    quadrennials = 24;
  }
  sec -= quadrennials * 126230400ULL;

  // Remove multiples of years (incl. 0 leap days), can't be more than 3
  // (because multiples of 4 years (incl. leap days) have been removed)
  annuals = (uint)(sec / 31536000); // 365*24*3600
  if (annuals > 3)
  {
    annuals = 3;
  }
  sec -= annuals * 31536000ULL;

  // Calculate the year and find out if it's leap
  year = 1601 + quadricentennials * 400 + centennials * 100 + quadrennials * 4 + annuals;
  leap = !(year % 4) && (year % 100 || !(year % 400));

  // Calculate the day of the year and the time
  yday = sec / 86400;
  sec %= 86400;
  hour = sec / 3600;
  sec %= 3600;
  min = sec / 60;
  sec %= 60;

  // Calculate the month
  for (mday = month = 1; month < 13; month++)
  {
    if (yday < daysSinceJan1st[leap][month])
    {
      mday += yday - daysSinceJan1st[leap][month - 1];
      break;
    }
  }

  // Fill in C's "struct tm"
  
  dt.Sec = sec;          // [0,59]
  dt.Min = min;          // [0,59]
  dt.Hour = hour;        // [0,23]
  dt.Mday = mday;        // [1,31]  (day of month)
  dt.Mon = month;    // [0,11]  (month)
  //Не знаю почему, но пусть будет так
	dt.Year = year-2000; // 70+     (year since 1900)
  

  return dt;
}


/*
	обнуляем время
*/
void rtc_time_clear(DateTimeT *d)
{
	DateTimeT temp = ticks_to_time(631139040000000000);
	memcpy(d,&temp,sizeof(temp));
}

